home *** CD-ROM | disk | FTP | other *** search
/ Aminet 30 / Aminet 30 (1999)(Schatztruhe)[!][Apr 1999].iso / Aminet / dev / lang / SmallEiffel.lha / SmallEiffel / bin_c / compile_to_jvm42.c < prev    next >
C/C++ Source or Header  |  1998-12-22  |  13KB  |  668 lines
  1. /*
  2. -- ANSI C code generated by :
  3. -- SmallEiffel The GNU Eiffel Compiler -- Release (- 0.79)      --
  4. -- Copyright (C), 1994-98 - LORIA - UHP - CRIN - INRIA - FRANCE --
  5. -- Dominique COLNET and Suzanne COLLIN -    colnet@loria.fr     --
  6. --                 http://www.loria.fr/SmallEiffel              --
  7. */
  8. #include "compile_to_jvm.h"
  9.  
  10.  
  11. T0* r234result_type(T234* C){
  12. T0* R=NULL;
  13. R=X109result_type((C)->_expression/*4*/);
  14. return R;
  15. }
  16.  
  17.  
  18. void r234error(T0* a1,T0* a2){
  19. r21add_position(a1);
  20. r21error((T21*)(oBC12eh),a2);
  21. }
  22.  
  23.  
  24. void r234make(T234* C,T0* a1,T0* a2){
  25. C->_expression=a1;
  26. C->_comment=a2;
  27. }
  28.  
  29.  
  30. void r234compile_to_jvm_assignment(T234* C,T0* a1){
  31. X109compile_to_jvm_assignment((C)->_expression/*4*/,a1);
  32. }
  33.  
  34.  
  35. T6 r234is_current(T234* C){
  36. T6 R=0;
  37. R=X109is_current((C)->_expression/*4*/);
  38. return R;
  39. }
  40.  
  41.  
  42. T6 r234is_void(T234* C){
  43. T6 R=0;
  44. R=X109is_void((C)->_expression/*4*/);
  45. return R;
  46. }
  47.  
  48.  
  49. void r234compile_to_jvm_old(T234* C){
  50. X109compile_to_jvm_old((C)->_expression/*4*/);
  51. }
  52.  
  53.  
  54. void r234jvm_assign(T234* C){
  55. X109jvm_assign((C)->_expression/*4*/);
  56. }
  57.  
  58.  
  59. T2 r234jvm_branch_if_false(T234* C){
  60. T2 R=0;
  61. R=X109jvm_branch_if_false((C)->_expression/*4*/);
  62. return R;
  63. }
  64. /*No:EXPRESSION_WITH_COMMENT.comment*/
  65.  
  66.  
  67. void r234compile_to_jvm(T234* C){
  68. X109compile_to_jvm((C)->_expression/*4*/);
  69. }
  70.  
  71.  
  72. void r234afd_check(T234* C){
  73. X109afd_check((C)->_expression/*4*/);
  74. }
  75.  
  76.  
  77. T6 r234is_result(T234* C){
  78. T6 R=0;
  79. R=X109is_result((C)->_expression/*4*/);
  80. return R;
  81. }
  82.  
  83.  
  84. T2 r146static_value(T146* C){
  85. T2 R=0;
  86. /*[IF*/
  87. if(X52is_integer(X109result_type((C)->_target/*4*/))){
  88. /*[IF*/
  89. if(X109is_static((C)->_target/*4*/)){
  90. R=-(X109static_value((C)->_target/*4*/));
  91. }
  92. /*FI]*/
  93. }
  94. /*FI]*/
  95. return R;
  96. }
  97. /*No:CALL_PREFIX_MINUS.feature_name*/
  98.  
  99.  
  100. T6 r146is_static(T146* C){
  101. T6 R=0;
  102. /*[IF*/
  103. if(X52is_integer(X109result_type((C)->_target/*4*/))){
  104. /*[IF*/
  105. if(X109is_static((C)->_target/*4*/)){
  106. R=1;
  107. }
  108. /*FI]*/
  109. }
  110. /*FI]*/
  111. return R;
  112. }
  113. /*No:CALL_PREFIX_MINUS.is_manifest_string*/
  114.  
  115.  
  116. T0* r146start_position(T146* C){
  117. T0* R=NULL;
  118. R=((T145*)((C)->_feature_name/*12*/))->_start_position/*8*/;
  119. return R;
  120. }
  121.  
  122.  
  123. T0* r146add_comment(T146* C,T0* a1){
  124. T0* R=NULL;
  125. /*[IF*/
  126. if(((a1)==((void*)(NULL)))||((/*(IRF4.6count*/r73count(((T73*)((((T85*)a1))->_list/*4*/)))/*)*/)==(0))){
  127. R=(T0*)C;
  128. }
  129. else{
  130. {T234*n=malloc(sizeof(*n));
  131. *n=M234;
  132. r234make(n,(T0*)C,a1);
  133. R=(T0*)n;
  134. }
  135. }
  136. /*FI]*/
  137. return R;
  138. }
  139.  
  140.  
  141. T2 r146to_integer(T146* C){
  142. T2 R=0;
  143. T0* _rf1=NULL;
  144. _rf1=(C)->_run_feature/*8*/;
  145. if(NULL!=(_rf1))switch(((T0*)_rf1)->id) {
  146. case 372: 
  147. break;
  148. default:
  149. _rf1=NULL;
  150. };/*[IF*/
  151. if((_rf1)==((void*)(NULL))){
  152. r146error(r146start_position(C),((T0*)ms13_45846));
  153. }
  154. else{
  155. R=X109to_integer((((T372*)_rf1))->_value/*36*/);
  156. }
  157. /*FI]*/
  158. return R;
  159. }
  160.  
  161.  
  162. T6 r146use_current(T146* C){
  163. T6 R=0;
  164. /*[IF*/
  165. /*AF*//*AE*/
  166. /*FI]*/
  167. /*[IF*/
  168. if(R){
  169. }
  170.  else if(X109is_current((C)->_target/*4*/)){
  171. R=X27use_current((C)->_run_feature/*8*/);
  172. }
  173. else{
  174. R=X109use_current((C)->_target/*4*/);
  175. }
  176. /*FI]*/
  177. return R;
  178. }
  179. /*No:CALL_PREFIX_MINUS.jvm_branch_if_true*/
  180.  
  181.  
  182. T0* r146to_runnable(T146* C,T0* a1){
  183. T0* R=NULL;
  184. T0* _rf=NULL;
  185. T0* _t=NULL;
  186. _t=r146runnable_expression((C)->_target/*4*/,a1);
  187. _rf=r146run_feature_for(C,_t,a1);
  188. /*[IF*/
  189. if(((C)->_run_feature/*8*/)==((void*)(NULL))){
  190. C->_target=_t;
  191. C->_run_feature=_rf;
  192. r146run_feature_match(C);
  193. R=(T0*)C;
  194. }
  195.  else if((_t)==((void*)((C)->_target/*4*/))){
  196. R=(T0*)C;
  197. }
  198. else{
  199. {T146*n=malloc(sizeof(*n));
  200. *n=M146;
  201. r146with(n,_t,(C)->_feature_name/*12*/,_rf);
  202. R=(T0*)n;
  203. }
  204. }
  205. /*FI]*/
  206. return R;
  207. }
  208.  
  209.  
  210. T2 r146compile_to_jvm_into(T146* C,T0* a1){
  211. T2 R=0;
  212. R=r146standard_compile_to_jvm_into(C,a1);
  213. return R;
  214. }
  215. /*No:CALL_PREFIX_MINUS.is_pre_computable*/
  216. /*No:CALL_PREFIX_MINUS.fz_iinaiv*/
  217.  
  218.  
  219. T0* r146result_type(T146* C){
  220. T0* R=NULL;
  221. R=X27result_type((C)->_run_feature/*8*/);
  222. /*[IF*/
  223. if(X52is_like_current(R)){
  224. R=/*X27current_type*/((T0*)((T26*)((C)->_run_feature/*8*/))->_current_type/*4*/);
  225. }
  226. /*FI]*/
  227. return R;
  228. }
  229. /*No:CALL_PREFIX_MINUS.run_feature*/
  230.  
  231.  
  232. void r146standard_compile_target_to_jvm(T146* C){
  233. /*[IRF3.4compile_to_jvm*//*[IRF3.6call_proc_call_c2jvm*/{T146* C1=C;
  234. r24call_proc_call_mapping((T24*)(oBC12jvm),(T0*)C1);
  235. }/*]*/
  236. /*]*/
  237. X52jvm_check_class_invariant(r146result_type(C));
  238. }
  239. /*No:CALL_PREFIX_MINUS.compile_to_jvm_assignment*/
  240. /*No:CALL_PREFIX_MINUS.fz_07*/
  241.  
  242.  
  243. void r146compile_to_jvm_old(T146* C){
  244. X109compile_to_jvm_old((C)->_target/*4*/);
  245. /*[IF*/
  246. /*AF*//*AE*/
  247. /*FI]*/
  248. }
  249. /*No:CALL_PREFIX_MINUS.jvm_assign*/
  250. /*No:CALL_PREFIX_MINUS.jvm_branch_if_false*/
  251. /*No:CALL_PREFIX_MINUS.compile_to_jvm*/
  252. /*No:CALL_PREFIX_MINUS.arg_count*/
  253.  
  254.  
  255. void r146with(T146* C,T0* a1,T0* a2,T0* a3){
  256. C->_target=a1;
  257. C->_feature_name=a2;
  258. C->_run_feature=a3;
  259. r146run_feature_match(C);
  260. }
  261. /*No:CALL_PREFIX_MINUS.call_proc_call_c2jvm*/
  262. /*No:CALL_PREFIX_MINUS.is_result*/
  263. /*No:CALL_PREFIX_MINUS.fatal_error*/
  264. /*No:CALL_PREFIX_MINUS.us_minus*/
  265.  
  266.  
  267. void r146run_feature_match(T146* C){
  268. r146run_feature_has_result(C);
  269. /*[IF*/
  270. if((X27arg_count((C)->_run_feature/*8*/))>(0)){
  271. r21add_position(((T145*)((C)->_feature_name/*12*/))->_start_position/*8*/);
  272. r21add_position(X27start_position((C)->_run_feature/*8*/));
  273. /*[IRF3.6fatal_error*/{T0* b1=((T0*)ms144_50512);
  274. r21fatal_error((T21*)(oBC12eh),b1);
  275. }/*]*/
  276. }
  277. /*FI]*/
  278. }
  279. /*No:CALL_PREFIX_MINUS.arguments*/
  280.  
  281.  
  282. T0* r146runnable_expression(T0* a1,T0* a2){
  283. T0* R=NULL;
  284. R=X109to_runnable(a1,a2);
  285. /*[IF*/
  286. if((R)==((void*)(NULL))){
  287. r21add_position(X109start_position(a1));
  288. /*[IRF3.6fatal_error*/{T0* b1=((T0*)ms121_16515);
  289. r21fatal_error((T21*)(oBC12eh),b1);
  290. }/*]*/
  291. }
  292. /*FI]*/
  293. return R;
  294. }
  295.  
  296.  
  297. T6 r146can_be_dropped(T146* C){
  298. T6 R=0;
  299. /*[IF*/
  300. if(X109can_be_dropped((C)->_target/*4*/)){
  301. R=X27can_be_dropped((C)->_run_feature/*8*/);
  302. }
  303. /*FI]*/
  304. return R;
  305. }
  306. /*No:CALL_PREFIX_MINUS.compile_target_to_jvm*/
  307.  
  308.  
  309. T2 r146isa_dca_inline_argument(T146* C){
  310. T2 R=0;
  311. /*[IF*/
  312. if(X52is_integer(r146result_type(C))){
  313. R=X109isa_dca_inline_argument((C)->_target/*4*/);
  314. }
  315. /*FI]*/
  316. return R;
  317. }
  318.  
  319.  
  320. void r146run_feature_has_result(T146* C){
  321. /*[IF*/
  322. if((X27result_type((C)->_run_feature/*8*/))==((void*)(NULL))){
  323. r21add_position(X27start_position((C)->_run_feature/*8*/));
  324. r21add_position(((T145*)((C)->_feature_name/*12*/))->_start_position/*8*/);
  325. /*[IRF3.6fatal_error*/{T0* b1=((T0*)ms120_53650);
  326. r21fatal_error((T21*)(oBC12eh),b1);
  327. }/*]*/
  328. }
  329. /*FI]*/
  330. }
  331.  
  332.  
  333. T2 r146jvm_standard_branch_if_false(T146* C){
  334. T2 R=0;
  335. /*[IRF3.4compile_to_jvm*//*[IRF3.6call_proc_call_c2jvm*/{T146* C1=C;
  336. r24call_proc_call_mapping((T24*)(oBC12jvm),(T0*)C1);
  337. }/*]*/
  338. /*]*/
  339. R=r28opcode_ifeq((T28*)(oBC12code_attribute));
  340. return R;
  341. }
  342.  
  343.  
  344. T0* r146run_feature_for(T146* C,T0* a1,T0* a2){
  345. T0* R=NULL;
  346. T0* _rc=NULL;
  347. _rc=X52run_class(X109result_type(a1));
  348. R=r23get_rf(((T23*)_rc),a1,(C)->_feature_name/*12*/,a2);
  349. return R;
  350. }
  351. /*No:CALL_PREFIX_MINUS.target*/
  352.  
  353.  
  354. void r146error(T0* a1,T0* a2){
  355. r21add_position(a1);
  356. r21error((T21*)(oBC12eh),a2);
  357. }
  358.  
  359.  
  360. void r146make(T146* C,T0* a1,T0* a2){
  361. {T145*n=malloc(sizeof(*n));
  362. *n=M145;
  363. r145make(n,r146operator(),a1);
  364. C->_feature_name=(T0*)n;
  365. }
  366. C->_target=a2;
  367. }
  368. /*No:CALL_PREFIX_MINUS.is_current*/
  369.  
  370.  
  371. T2 r146standard_compile_to_jvm_into(T146* C,T0* a1){
  372. T2 R=0;
  373. /*[IRF3.4compile_to_jvm*//*[IRF3.6call_proc_call_c2jvm*/{T146* C1=C;
  374. r24call_proc_call_mapping((T24*)(oBC12jvm),(T0*)C1);
  375. }/*]*/
  376. /*]*/
  377. R=X52jvm_convert_to(X52run_type(r146result_type(C)),a1);
  378. return R;
  379. }
  380. /*No:CALL_PREFIX_MINUS.is_void*/
  381.  
  382.  
  383. T0* r146operator(void){
  384. T0* R=NULL;
  385. R=((T0*)ms14_46);
  386. return R;
  387. }
  388.  
  389.  
  390. T2 r146jvm_standard_branch_if_true(T146* C){
  391. T2 R=0;
  392. /*[IRF3.4compile_to_jvm*//*[IRF3.6call_proc_call_c2jvm*/{T146* C1=C;
  393. r24call_proc_call_mapping((T24*)(oBC12jvm),(T0*)C1);
  394. }/*]*/
  395. /*]*/
  396. R=r28opcode_ifne((T28*)(oBC12code_attribute));
  397. return R;
  398. }
  399.  
  400.  
  401. void r146afd_check(T146* C){
  402. T0* _running=NULL;
  403. T0* _rc=NULL;
  404. _rc=X52run_class(X109result_type((C)->_target/*4*/));
  405. _running=(((T23*)_rc))->_running/*12*/;
  406. /*[IF*/
  407. if((_running)==((void*)(NULL))){
  408. r21add_position(X109start_position((C)->_target/*4*/));
  409. /*[IRF3.6append*/{T0* b1=((T0*)ms121_181815);
  410. r7append((T7*)(oBC21explanation),b1);
  411. }/*]*/
  412. /*[IRF3.6append*/{T0* b1=X52run_time_mark((((T23*)_rc))->_current_type/*0*/);
  413. r7append((T7*)(oBC21explanation),b1);
  414. }/*]*/
  415. /*[IRF3.6append*/{T0* b1=((T0*)ms13_20094);
  416. r7append((T7*)(oBC21explanation),b1);
  417. }/*]*/
  418. r21print_as_warning((T21*)(oBC12eh));
  419. r23set_at_run_time(((T23*)_rc));
  420. }
  421.  else if((r340count(((T340*)_running)))>(1)){
  422. r335update((C)->_target/*4*/,(C)->_run_feature/*8*/);
  423. }
  424. /*FI]*/
  425. X109afd_check((C)->_target/*4*/);
  426. /*[IF*/
  427. /*AF*//*AE*/
  428. /*FI]*/
  429. }
  430. /*No:E_FALSE.static_value*/
  431.  
  432.  
  433. T0* r172type_boolean(void){
  434. if(fBC12type_boolean==0){
  435. fBC12type_boolean=1;
  436. {T268*n=malloc(sizeof(*n));
  437. *n=M268;
  438. r268make(n,NULL);
  439. oBC12type_boolean=(T0*)n;
  440. }
  441. }
  442. return oBC12type_boolean;}
  443. /*No:E_FALSE.is_static*/
  444. /*No:E_FALSE.can_be_dropped*/
  445. /*No:E_FALSE.is_manifest_string*/
  446. /*No:E_FALSE.start_position*/
  447.  
  448.  
  449. T0* r172add_comment(T172* C,T0* a1){
  450. T0* R=NULL;
  451. /*[IF*/
  452. if(((a1)==((void*)(NULL)))||((/*(IRF4.6count*/r73count(((T73*)((((T85*)a1))->_list/*4*/)))/*)*/)==(0))){
  453. R=(T0*)C;
  454. }
  455. else{
  456. {T234*n=malloc(sizeof(*n));
  457. *n=M234;
  458. r234make(n,(T0*)C,a1);
  459. R=(T0*)n;
  460. }
  461. }
  462. /*FI]*/
  463. return R;
  464. }
  465. /*No:E_FALSE.compile_target_to_jvm*/
  466. /*No:E_FALSE.to_integer*/
  467. /*No:E_FALSE.use_current*/
  468.  
  469.  
  470. T2 r172jvm_branch_if_true(void){
  471. T2 R=0;
  472. /*[IRF3.4opcode_iconst_0*/r28opcode((T28*)(oBC12code_attribute),3,1);
  473. /*]*/
  474. R=r28opcode_ifeq((T28*)(oBC12code_attribute));
  475. return R;
  476. }
  477. /*No:E_FALSE.to_runnable*/
  478.  
  479.  
  480. T2 r172compile_to_jvm_into(T0* a1){
  481. T2 R=0;
  482. R=r172standard_compile_to_jvm_into(a1);
  483. return R;
  484. }
  485.  
  486.  
  487. T2 r172isa_dca_inline_argument(void){
  488. T2 R=0;
  489. /*[IF*/
  490. {/*AT*/R=-(1);
  491. }
  492. /*FI]*/
  493. return R;
  494. }
  495. /*No:E_FALSE.is_pre_computable*/
  496. /*No:E_FALSE.fz_iinaiv*/
  497. /*No:E_FALSE.result_type*/
  498.  
  499.  
  500. void r172error(T0* a1,T0* a2){
  501. r21add_position(a1);
  502. r21error((T21*)(oBC12eh),a2);
  503. }
  504. /*No:E_FALSE.make*/
  505. /*No:E_FALSE.compile_to_jvm_assignment*/
  506. /*No:E_FALSE.is_current*/
  507.  
  508.  
  509. T2 r172standard_compile_to_jvm_into(T0* a1){
  510. T2 R=0;
  511. /*[IRF3.2compile_to_jvm*//*[IRF3.4opcode_iconst_0*/r28opcode((T28*)(oBC12code_attribute),3,1);
  512. /*]*/
  513. /*]*/
  514. R=X52jvm_convert_to(/*(IRF4.4run_type*/((T0*)((T268*)/*(IRF4.8result_type*/r172type_boolean()/*)*/))/*)*/,a1);
  515. return R;
  516. }
  517. /*No:E_FALSE.is_void*/
  518. /*No:E_FALSE.compile_to_jvm_old*/
  519. /*No:E_FALSE.jvm_assign*/
  520. /*No:E_FALSE.jvm_branch_if_false*/
  521. /*No:E_FALSE.compile_to_jvm*/
  522. /*No:E_FALSE.afd_check*/
  523. /*No:E_FALSE.is_result*/
  524. /*No:ARGUMENT_NAME2.static_value*/
  525. /*No:ARGUMENT_NAME2.is_static*/
  526. /*No:ARGUMENT_NAME2.is_manifest_string*/
  527. /*No:ARGUMENT_NAME2.start_position*/
  528.  
  529.  
  530. T0* r192to_string(T192* C){
  531. T0* R=NULL;
  532. R=((T194*)(/*(IRF4.6name*/r195item(((T195*)(((T191*)((C)->_formal_arg_list/*12*/))->_flat_list/*8*/)),(C)->_rank/*8*/)/*)*/))->_to_string/*8*/;
  533. return R;
  534. }
  535.  
  536.  
  537. T0* r192add_comment(T192* C,T0* a1){
  538. T0* R=NULL;
  539. /*[IF*/
  540. if(((a1)==((void*)(NULL)))||((/*(IRF4.6count*/r73count(((T73*)((((T85*)a1))->_list/*4*/)))/*)*/)==(0))){
  541. R=(T0*)C;
  542. }
  543. else{
  544. {T234*n=malloc(sizeof(*n));
  545. *n=M234;
  546. r234make(n,(T0*)C,a1);
  547. R=(T0*)n;
  548. }
  549. }
  550. /*FI]*/
  551. return R;
  552. }
  553.  
  554.  
  555. T2 r192to_integer(T192* C){
  556. T2 R=0;
  557. r192error((C)->_start_position/*4*/,((T0*)ms13_45846));
  558. return R;
  559. }
  560. /*No:ARGUMENT_NAME2.rank*/
  561. /*No:ARGUMENT_NAME2.use_current*/
  562.  
  563.  
  564. T2 r192jvm_branch_if_true(T192* C){
  565. T2 R=0;
  566. r192compile_to_jvm(C);
  567. R=r28opcode_ifne((T28*)(oBC12code_attribute));
  568. return R;
  569. }
  570.  
  571.  
  572. T0* r192to_runnable(T192* C,T0* a1){
  573. T0* R=NULL;
  574. T0* _fal=NULL;
  575. T0* _rf=NULL;
  576. _rf=r22top_rf((T22*)(oBC12small_eiffel));
  577. _fal=X27arguments(_rf);
  578. /*[IF*/
  579. if(((C)->_formal_arg_list/*12*/)==((void*)(_fal))){
  580. R=(T0*)C;
  581. }
  582. else{
  583. {T192*n=malloc(sizeof(*n));
  584. *n=M192;
  585. r192with(n,(T0*)C,_fal);
  586. R=(T0*)n;
  587. }
  588. }
  589. /*FI]*/
  590. return R;
  591. }
  592.  
  593.  
  594. T2 r192compile_to_jvm_into(T192* C,T0* a1){
  595. T2 R=0;
  596. R=r192standard_compile_to_jvm_into(C,a1);
  597. return R;
  598. }
  599. /*No:ARGUMENT_NAME2.is_pre_computable*/
  600. /*No:ARGUMENT_NAME2.fz_iinaiv*/
  601.  
  602.  
  603. T0* r192result_type(T192* C){
  604. T0* R=NULL;
  605. R=r191type((T191*)((C)->_formal_arg_list/*12*/),(C)->_rank/*8*/);
  606. return R;
  607. }
  608.  
  609.  
  610. void r192standard_compile_target_to_jvm(T192* C){
  611. r192compile_to_jvm(C);
  612. X52jvm_check_class_invariant(r192result_type(C));
  613. }
  614. /*No:ARGUMENT_NAME2.compile_to_jvm_assignment*/
  615. /*No:ARGUMENT_NAME2.compile_to_jvm_old*/
  616. /*No:ARGUMENT_NAME2.jvm_assign*/
  617.  
  618.  
  619. T2 r192jvm_branch_if_false(T192* C){
  620. T2 R=0;
  621. r192compile_to_jvm(C);
  622. R=r28opcode_ifeq((T28*)(oBC12code_attribute));
  623. return R;
  624. }
  625.  
  626.  
  627. void r192compile_to_jvm(T192* C){
  628. T2 _jvm_offset=0;
  629. _jvm_offset=r24argument_offset_of((T24*)(oBC12jvm),(T0*)C);
  630. X52jvm_push_local(X52run_type(r192result_type(C)),_jvm_offset);
  631. }
  632.  
  633.  
  634. void r192with(T192* C,T0* a1,T0* a2){
  635. *((T192*)(C))=*((T192*)(a1));
  636. C->_formal_arg_list=a2;
  637. }
  638. /*No:ARGUMENT_NAME2.is_result*/
  639. /*No:ARGUMENT_NAME2.can_be_dropped*/
  640. /*No:ARGUMENT_NAME2.compile_target_to_jvm*/
  641. /*No:ARGUMENT_NAME2.isa_dca_inline_argument*/
  642. /*No:ARGUMENT_NAME2.formal_arg_list*/
  643.  
  644.  
  645. void r192refer_to(T192* C,T0* a1,T0* a2,T2 a3){
  646. C->_start_position=a1;
  647. C->_formal_arg_list=a2;
  648. C->_rank=a3;
  649. }
  650.  
  651.  
  652. void r192error(T0* a1,T0* a2){
  653. r21add_position(a1);
  654. r21error((T21*)(oBC12eh),a2);
  655. }
  656. /*No:ARGUMENT_NAME2.is_current*/
  657.  
  658.  
  659. T2 r192standard_compile_to_jvm_into(T192* C,T0* a1){
  660. T2 R=0;
  661. r192compile_to_jvm(C);
  662. R=X52jvm_convert_to(X52run_type(r192result_type(C)),a1);
  663. return R;
  664. }
  665. /*No:ARGUMENT_NAME2.is_void*/
  666. /*No:ARGUMENT_NAME2.afd_check*/
  667.  
  668.